
#include <stdio.h>
#include <stdlib.h>
#define ListSize 100  // 表的大小根据实际需要定义
typedef int DataType; // DataType 的数据类型根据实际情况而定

// 声明顺序表结构，通过typedef定义，在使用时可省略 struct 字段
typedef struct
{
    DataType data[ListSize]; // 数组data用来存放表结构
    int length;              // 线性表的当前长度（实际元素的个数）
} SeqList;                   // 顺序表的数据类型

// 函数声明
void printArray(SeqList *L);
// 元素插入指定位置
void insertList(SeqList *L, int i, DataType x);
// 删除指定位置元素，返回删除的元素
int deleteList(SeqList *L, int i);

// 顺序表翻转, 通过值传递
SeqList reversed(SeqList L)
{
    // 创建临时变量
    DataType temp;
    // 只需将前、后的元素对调即可
    int loopTimes = L.length / 2;
    for (int i = 0; i < loopTimes; i++)
    {
        temp = L.data[i];
        L.data[i] = L.data[L.length - 1 - i];
        L.data[L.length - 1 - i] = temp;
    }

    return L;
}
// 顺序表翻转，通过地址传递
SeqList reversed2(SeqList *L)
{
    // 创建临时变量
    DataType temp;
    // 只需将前、后的元素对调即可
    int loopTimes = L->length / 2;
    for (int i = 0; i < loopTimes; i++)
    {
        temp = L->data[i];
        L->data[i] = L->data[L->length - 1 - i];
        L->data[L->length - 1 - i] = temp;
    }

    return *L;
}

typedef struct map
{
    int keyWord;
    int values;
} Map;

Map *getMaxAndMin(SeqList L)
{
    int max = L.data[0];
    int min = L.data[0];

    static Map mapList[2];
    mapList[0].keyWord = 0;
    mapList[0].values = max;
    mapList[1].keyWord = 0;
    mapList[1].values = min;

    for (int i = 1; i < L.length; i++)
    {
        if (L.data[i] > max)
        {
            max = L.data[i];
            mapList[0].keyWord = i;
            mapList[0].values = max;
        }
        else if (L.data[i] < min)
        {
            min = L.data[i];
            mapList[1].keyWord = i;
            mapList[1].values = min;
        }
    }

    // 返回数组需是静态的
    printf("max=%d, index=%d\n", mapList[0].values, mapList[0].keyWord);
    printf("min=%d, index=%d\n", mapList[1].values, mapList[1].keyWord);
    return mapList;
}

int main()
{
    printf("%s\n", "test");
    SeqList seq;
    seq.length = 2;
    seq.data[0] = 1;
    seq.data[1] = 3;
    // printArray(&seq);

    insertList(&seq, 1, 6);
    // deleteList(&seq, 4);
    printArray(&seq);

    // 顺序表翻转
    // SeqList result1 = reversed(seq);
    // SeqList result2 = reversed2(&seq);
    // printArray(&result1);
    // printArray(&result2);

    // 找出最大值和最小值及其元素位置
    Map *m = getMaxAndMin(seq);
    // for (int i = 0; i < 2; i++)
    // {
    //     printf("values=%d, index=%d\n", m[i].values, m[i].keyWord);
    // }

    return 0;
}

// 函数定义
void printArray(SeqList *L)
{
    int arrSize = sizeof(L) / sizeof(DataType);
    printf("=======print arrays element=======%d\n", arrSize);
    for (int i = 0; i < L->length; i++)
    {
        printf("%d\n", L->data[i]);
    }
    printf("\n");
}

void insertList(SeqList *L, int i, DataType x)
{
    // 判断插入位置是否在元素区间内
    if (i < 1 || i > L->length - 1)
    {
        printf("position error\n");
        return;
    }

    // 判断数组长度是否超出指定长度
    printf("length=%d, size=%d\n", L->length, ListSize);
    if (L->length >= ListSize)
    {
        printf("out of array length\n");
        return;
    }
    // 实现移动操作, 从最后一个开始移动
    for (int j = L->length - 1; j >= i - 1; j--)
    {
        L->data[j + 1] = L->data[j];
    }

    // 插入新的元素
    L->data[i - 1] = x;
    // 数组长度+1
    L->length++;
}
int deleteList(SeqList *L, int i)
{
    // 合法性判断
    if (i < 1 || i > L->length)
    {
        printf("position error\n");
        exit(0);
    }
    // 保存 将要删除的元素
    DataType x = L->data[i - 1];
    for (int j = i - 1; j < L->length - 1; j++)
    {
        L->data[j] = L->data[j + 1];
    }

    L->length--;
    return x;
}